/*
 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package java.awt;

import java.io.IOException;
import java.awt.image.*;
import java.net.URL;
import java.net.URLConnection;
import java.io.File;
import sun.util.logging.PlatformLogger;
import sun.awt.image.SunWritableRaster;

/**
 * The splash screen can be displayed at application startup, before the
 * Java Virtual Machine (JVM) starts. The splash screen is displayed as an
 * undecorated window containing an image. You can use GIF, JPEG, or PNG files
 * for the image. Animation is supported for the GIF format, while transparency
 * is supported both for GIF and PNG.  The window is positioned at the center
 * of the screen. The position on multi-monitor systems is not specified. It is
 * platform and implementation dependent.  The splash screen window is closed
 * automatically as soon as the first window is displayed by Swing/AWT (may be
 * also closed manually using the Java API, see below).
 * <P>
 * If your application is packaged in a jar file, you can use the
 * "SplashScreen-Image" option in a manifest file to show a splash screen.
 * Place the image in the jar archive and specify the path in the option.
 * The path should not have a leading slash.
 * <BR>
 * For example, in the <code>manifest.mf</code> file:
 * <PRE>
 * Manifest-Version: 1.0
 * Main-Class: Test
 * SplashScreen-Image: filename.gif
 * </PRE>
 * <P>
 * If the Java implementation provides the command-line interface and you run
 * your application by using the command line or a shortcut, use the Java
 * application launcher option to show a splash screen. The Oracle reference
 * implementation allows you to specify the splash screen image location with
 * the {@code -splash:} option.
 * <BR>
 * For example:
 * <PRE>
 * java -splash:filename.gif Test
 * </PRE>
 * The command line interface has higher precedence over the manifest
 * setting.
 * <p>
 * The splash screen will be displayed as faithfully as possible to present the
 * whole splash screen image given the limitations of the target platform and
 * display.
 * <p>
 * It is implied that the specified image is presented on the screen "as is",
 * i.e. preserving the exact color values as specified in the image file. Under
 * certain circumstances, though, the presented image may differ, e.g. when
 * applying color dithering to present a 32 bits per pixel (bpp) image on a 16
 * or 8 bpp screen. The native platform display configuration may also affect
 * the colors of the displayed image (e.g.  color profiles, etc.)
 * <p>
 * The {@code SplashScreen} class provides the API for controlling the splash
 * screen. This class may be used to close the splash screen, change the splash
 * screen image, get the splash screen native window position/size, and paint
 * in the splash screen. It cannot be used to create the splash screen. You
 * should use the options provided by the Java implementation for that.
 * <p>
 * This class cannot be instantiated. Only a single instance of this class
 * can exist, and it may be obtained by using the {@link #getSplashScreen()}
 * static method. In case the splash screen has not been created at
 * application startup via the command line or manifest file option,
 * the <code>getSplashScreen</code> method returns <code>null</code>.
 *
 * @author Oleg Semenov
 * @since 1.6
 */
public final class SplashScreen {

  SplashScreen(long ptr) { // non-public constructor
    splashPtr = ptr;
  }

  /**
   * Returns the {@code SplashScreen} object used for
   * Java startup splash screen control on systems that support display.
   *
   * @return the {@link SplashScreen} instance, or <code>null</code> if there is none or it has
   * already been closed
   * @throws UnsupportedOperationException if the splash screen feature is not supported by the
   * current toolkit
   * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()} returns true
   */
  public static SplashScreen getSplashScreen() {
    synchronized (SplashScreen.class) {
      if (GraphicsEnvironment.isHeadless()) {
        throw new HeadlessException();
      }
      // SplashScreen class is now a singleton
      if (!wasClosed && theInstance == null) {
        java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction<Void>() {
              public Void run() {
                System.loadLibrary("splashscreen");
                return null;
              }
            });
        long ptr = _getInstance();
        if (ptr != 0 && _isVisible(ptr)) {
          theInstance = new SplashScreen(ptr);
        }
      }
      return theInstance;
    }
  }

  /**
   * Changes the splash screen image. The new image is loaded from the
   * specified URL; GIF, JPEG and PNG image formats are supported.
   * The method returns after the image has finished loading and the window
   * has been updated.
   * The splash screen window is resized according to the size of
   * the image and is centered on the screen.
   *
   * @param imageURL the non-<code>null</code> URL for the new splash screen image
   * @throws NullPointerException if {@code imageURL} is <code>null</code>
   * @throws IOException if there was an error while loading the image
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public void setImageURL(URL imageURL)
      throws NullPointerException, IOException, IllegalStateException {
    checkVisible();
    URLConnection connection = imageURL.openConnection();
    connection.connect();
    int length = connection.getContentLength();
    java.io.InputStream stream = connection.getInputStream();
    byte[] buf = new byte[length];
    int off = 0;
    while (true) {
      // check for available data
      int available = stream.available();
      if (available <= 0) {
        // no data available... well, let's try reading one byte
        // we'll see what happens then
        available = 1;
      }
      // check for enough room in buffer, realloc if needed
      // the buffer always grows in size 2x minimum
      if (off + available > length) {
        length = off * 2;
        if (off + available > length) {
          length = available + off;
        }
        byte[] oldBuf = buf;
        buf = new byte[length];
        System.arraycopy(oldBuf, 0, buf, 0, off);
      }
      // now read the data
      int result = stream.read(buf, off, available);
      if (result < 0) {
        break;
      }
      off += result;
    }
    synchronized (SplashScreen.class) {
      checkVisible();
      if (!_setImageData(splashPtr, buf)) {
        throw new IOException("Bad image format or i/o error when loading image");
      }
      this.imageURL = imageURL;
    }
  }

  private void checkVisible() {
    if (!isVisible()) {
      throw new IllegalStateException("no splash screen available");
    }
  }

  /**
   * Returns the current splash screen image.
   *
   * @return URL for the current splash screen image file
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public URL getImageURL() throws IllegalStateException {
    synchronized (SplashScreen.class) {
      checkVisible();
      if (imageURL == null) {
        try {
          String fileName = _getImageFileName(splashPtr);
          String jarName = _getImageJarName(splashPtr);
          if (fileName != null) {
            if (jarName != null) {
              imageURL = new URL("jar:" + (new File(jarName).toURL().toString()) + "!/" + fileName);
            } else {
              imageURL = new File(fileName).toURL();
            }
          }
        } catch (java.net.MalformedURLException e) {
          if (log.isLoggable(PlatformLogger.Level.FINE)) {
            log.fine("MalformedURLException caught in the getImageURL() method", e);
          }
        }
      }
      return imageURL;
    }
  }

  /**
   * Returns the bounds of the splash screen window as a {@link Rectangle}.
   * This may be useful if, for example, you want to replace the splash
   * screen with your window at the same location.
   * <p>
   * You cannot control the size or position of the splash screen.
   * The splash screen size is adjusted automatically when the image changes.
   * <p>
   * The image may contain transparent areas, and thus the reported bounds may
   * be larger than the visible splash screen image on the screen.
   *
   * @return a {@code Rectangle} containing the splash screen bounds
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public Rectangle getBounds() throws IllegalStateException {
    synchronized (SplashScreen.class) {
      checkVisible();
      float scale = _getScaleFactor(splashPtr);
      Rectangle bounds = _getBounds(splashPtr);
      assert scale > 0;
      if (scale > 0 && scale != 1) {
        bounds.setSize((int) (bounds.getWidth() / scale),
            (int) (bounds.getWidth() / scale));
      }
      return bounds;
    }
  }

  /**
   * Returns the size of the splash screen window as a {@link Dimension}.
   * This may be useful if, for example,
   * you want to draw on the splash screen overlay surface.
   * <p>
   * You cannot control the size or position of the splash screen.
   * The splash screen size is adjusted automatically when the image changes.
   * <p>
   * The image may contain transparent areas, and thus the reported size may
   * be larger than the visible splash screen image on the screen.
   *
   * @return a {@link Dimension} object indicating the splash screen size
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public Dimension getSize() throws IllegalStateException {
    return getBounds().getSize();
  }

  /**
   * Creates a graphics context (as a {@link Graphics2D} object) for the splash
   * screen overlay image, which allows you to draw over the splash screen.
   * Note that you do not draw on the main image but on the image that is
   * displayed over the main image using alpha blending. Also note that drawing
   * on the overlay image does not necessarily update the contents of splash
   * screen window. You should call {@code update()} on the
   * <code>SplashScreen</code> when you want the splash screen to be
   * updated immediately.
   * <p>
   * The pixel (0, 0) in the coordinate space of the graphics context
   * corresponds to the origin of the splash screen native window bounds (see
   * {@link #getBounds()}).
   *
   * @return graphics context for the splash screen overlay surface
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public Graphics2D createGraphics() throws IllegalStateException {
    synchronized (SplashScreen.class) {
      checkVisible();
      if (image == null) {
        // get unscaled splash image size
        Dimension dim = _getBounds(splashPtr).getSize();
        image = new BufferedImage(dim.width, dim.height,
            BufferedImage.TYPE_INT_ARGB);
      }
      float scale = _getScaleFactor(splashPtr);
      Graphics2D g = image.createGraphics();
      assert (scale > 0);
      if (scale <= 0) {
        scale = 1;
      }
      g.scale(scale, scale);
      return g;
    }
  }

  /**
   * Updates the splash window with current contents of the overlay image.
   *
   * @throws IllegalStateException if the overlay image does not exist; for example, if {@code
   * createGraphics} has never been called, or if the splash screen has already been closed
   */
  public void update() throws IllegalStateException {
    BufferedImage image;
    synchronized (SplashScreen.class) {
      checkVisible();
      image = this.image;
    }
    if (image == null) {
      throw new IllegalStateException("no overlay image available");
    }
    DataBuffer buf = image.getRaster().getDataBuffer();
    if (!(buf instanceof DataBufferInt)) {
      throw new AssertionError(
          "Overlay image DataBuffer is of invalid type == " + buf.getClass().getName());
    }
    int numBanks = buf.getNumBanks();
    if (numBanks != 1) {
      throw new AssertionError(
          "Invalid number of banks ==" + numBanks + " in overlay image DataBuffer");
    }
    if (!(image.getSampleModel() instanceof SinglePixelPackedSampleModel)) {
      throw new AssertionError(
          "Overlay image has invalid sample model == " + image.getSampleModel().getClass()
              .getName());
    }
    SinglePixelPackedSampleModel sm = (SinglePixelPackedSampleModel) image.getSampleModel();
    int scanlineStride = sm.getScanlineStride();
    Rectangle rect = image.getRaster().getBounds();
    // Note that we steal the data array here, but just for reading
    // so we do not need to mark the DataBuffer dirty...
    int[] data = SunWritableRaster.stealData((DataBufferInt) buf, 0);
    synchronized (SplashScreen.class) {
      checkVisible();
      _update(splashPtr, data, rect.x, rect.y, rect.width, rect.height, scanlineStride);
    }
  }

  /**
   * Hides the splash screen, closes the window, and releases all associated
   * resources.
   *
   * @throws IllegalStateException if the splash screen has already been closed
   */
  public void close() throws IllegalStateException {
    synchronized (SplashScreen.class) {
      checkVisible();
      _close(splashPtr);
      image = null;
      SplashScreen.markClosed();
    }
  }

  static void markClosed() {
    synchronized (SplashScreen.class) {
      wasClosed = true;
      theInstance = null;
    }
  }


  /**
   * Determines whether the splash screen is visible. The splash screen may
   * be hidden using {@link #close()}, it is also hidden automatically when
   * the first AWT/Swing window is made visible.
   * <p>
   * Note that the native platform may delay presenting the splash screen
   * native window on the screen. The return value of {@code true} for this
   * method only guarantees that the conditions to hide the splash screen
   * window have not occurred yet.
   *
   * @return true if the splash screen is visible (has not been closed yet), false otherwise
   */
  public boolean isVisible() {
    synchronized (SplashScreen.class) {
      return !wasClosed && _isVisible(splashPtr);
    }
  }

  private BufferedImage image; // overlay image

  private final long splashPtr; // pointer to native Splash structure
  private static boolean wasClosed = false;

  private URL imageURL;

  /**
   * The instance reference for the singleton.
   * (<code>null</code> if no instance exists yet.)
   *
   * @see #getSplashScreen
   * @see #close
   */
  private static SplashScreen theInstance = null;

  private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.SplashScreen");

  private native static void _update(long splashPtr, int[] data, int x, int y, int width,
      int height, int scanlineStride);

  private native static boolean _isVisible(long splashPtr);

  private native static Rectangle _getBounds(long splashPtr);

  private native static long _getInstance();

  private native static void _close(long splashPtr);

  private native static String _getImageFileName(long splashPtr);

  private native static String _getImageJarName(long SplashPtr);

  private native static boolean _setImageData(long SplashPtr, byte[] data);

  private native static float _getScaleFactor(long SplashPtr);

}
